home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termFastMacros.c < prev    next >
C/C++ Source or Header  |  1995-02-07  |  6KB  |  322 lines
  1. /*
  2. **    termFastMacros.c
  3. **
  4. **    Fast! macros support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* NewFastMacro(STRPTR Macro,STRPTR Code):
  13.      *
  14.      *    Create a new fast! macro node.
  15.      */
  16.  
  17. struct MacroNode * __regargs
  18. NewFastMacro(STRPTR Macro,STRPTR Code)
  19. {
  20.     if(FastMacroCount + 1 < 10000)
  21.     {
  22.         struct MacroNode *Node;
  23.  
  24.         if(Node = (struct MacroNode *)AllocVecPooled(sizeof(struct MacroNode) + 21 + 257,MEMF_ANY|MEMF_CLEAR))
  25.         {
  26.             Node -> mn_Macro    = (STRPTR)(Node + 1);
  27.             Node -> mn_Code        = &Node -> mn_Macro[21];
  28.  
  29.             strcpy(Node -> mn_Macro,Macro);
  30.             strcpy(Node -> mn_Code ,Code);
  31.  
  32.             return(Node);
  33.         }
  34.     }
  35.  
  36.     return(NULL);
  37. }
  38.  
  39.     /* SaveFastMacros(STRPTR Name):
  40.      *
  41.      *    Save the fast! macro list to a file.
  42.      */
  43.  
  44. BOOLEAN __regargs
  45. SaveFastMacros(STRPTR Name,struct List *FastMacroList)
  46. {
  47.     struct IFFHandle    *Handle;
  48.     BOOLEAN             Success = FALSE;
  49.     LONG             Error = 0;
  50.  
  51.     if(Handle = (struct IFFHandle *)AllocIFF())
  52.     {
  53.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  54.         {
  55.             InitIFFasDOS(Handle);
  56.  
  57.             if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  58.             {
  59.                 if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
  60.                 {
  61.                     if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  62.                     {
  63.                         if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  64.                         {
  65.                             struct TermInfo TermInfo;
  66.  
  67.                             TermInfo . Version    = CONFIG_FILE_VERSION;
  68.                             TermInfo . Revision    = CONFIG_FILE_REVISION;
  69.  
  70.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  71.                             {
  72.                                 if(Error = PopChunk(Handle))
  73.                                     Success = FALSE;
  74.                                 else
  75.                                 {
  76.                                     struct MacroNode *Node;
  77.  
  78.                                     Node = (struct MacroNode *)FastMacroList -> lh_Head;
  79.  
  80.                                     while(Node -> mn_Succ)
  81.                                     {
  82.                                         if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  83.                                         {
  84.                                             if(!(Error = PushChunk(Handle,0,ID_FAST,IFFSIZE_UNKNOWN)))
  85.                                             {
  86.                                                 if(WriteChunkBytes(Handle,Node -> mn_Macro,20) != 20)
  87.                                                 {
  88.                                                     Error = IoErr();
  89.  
  90.                                                     Success = FALSE;
  91.  
  92.                                                     break;
  93.                                                 }
  94.                                                 else
  95.                                                 {
  96.                                                     if(WriteChunkBytes(Handle,Node -> mn_Code,256) != 256)
  97.                                                     {
  98.                                                         Error = IoErr();
  99.  
  100.                                                         Success = FALSE;
  101.  
  102.                                                         break;
  103.                                                     }
  104.                                                     else
  105.                                                     {
  106.                                                         if(Error = PopChunk(Handle))
  107.                                                         {
  108.                                                             Success = FALSE;
  109.  
  110.                                                             break;
  111.                                                         }
  112.                                                         else
  113.                                                             Success = TRUE;
  114.                                                     }
  115.                                                 }
  116.                                             }
  117.  
  118.                                             if(Success)
  119.                                             {
  120.                                                 if(Error = PopChunk(Handle))
  121.                                                 {
  122.                                                     Success = FALSE;
  123.  
  124.                                                     break;
  125.                                                 }
  126.                                             }
  127.                                         }
  128.  
  129.                                         Node = Node -> mn_Succ;
  130.                                     }
  131.                                 }
  132.                             }
  133.                             else
  134.                                 Error = IoErr();
  135.                         }
  136.  
  137.                         if(Success)
  138.                         {
  139.                             if(Error = PopChunk(Handle))
  140.                                 Success = FALSE;
  141.                         }
  142.                     }
  143.  
  144.                     if(Success)
  145.                     {
  146.                         if(Error = PopChunk(Handle))
  147.                             Success = FALSE;
  148.                     }
  149.                 }
  150.  
  151.                 CloseIFF(Handle);
  152.             }
  153.  
  154.             Close(Handle -> iff_Stream);
  155.         }
  156.         else
  157.             Error = IoErr();
  158.  
  159.         FreeIFF(Handle);
  160.     }
  161.     else
  162.         Error = ERR_NO_MEM;
  163.  
  164.     if(Success)
  165.         AddProtection(Name,FIBF_EXECUTE);
  166.     else
  167.         DeleteFile(Name);
  168.  
  169.     if(Error)
  170.         SetIoErr(Error);
  171.  
  172.     return(Success);
  173. }
  174.  
  175.     /* LoadFastMacros(STRPTR Name):
  176.      *
  177.      *    Restore the fast! macro list from a file.
  178.      */
  179.  
  180. BOOLEAN __regargs
  181. LoadFastMacros(STRPTR Name,struct List *FastMacroList)
  182. {
  183.     STATIC ULONG Stops[6] =
  184.     {
  185.         ID_TERM,ID_VERS,
  186.         ID_TERM,ID_FAST,
  187.         ID_TERM,ID_WIND
  188.     };
  189.  
  190.     struct List __aligned     NewFastMacroList;
  191.     LONG             NewFastMacroCount = 0;
  192.     struct IFFHandle    *Handle;
  193.     BOOLEAN             Success = FALSE;
  194.     struct MacroNode    *Node;
  195.     struct ContextNode    *Chunk;
  196.     struct IBox         SizeBox;
  197.     LONG             Error = 0;
  198.  
  199.     NewList(&NewFastMacroList);
  200.  
  201.     if(Handle = AllocIFF())
  202.     {
  203.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  204.         {
  205.             InitIFFasDOS(Handle);
  206.  
  207.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  208.             {
  209.                 if(!(Error = StopChunks(Handle,(LONG *)Stops,3)))
  210.                 {
  211.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  212.                     {
  213.                         Chunk = CurrentChunk(Handle);
  214.  
  215.                         if(Chunk -> cn_ID == ID_VERS)
  216.                         {
  217.                             struct TermInfo TermInfo;
  218.  
  219.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  220.                             {
  221.                                 if((TermInfo . Version > CONFIG_FILE_VERSION) || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  222.                                 {
  223.                                     Error = ERR_OUTDATED;
  224.  
  225.                                     break;
  226.                                 }
  227.                             }
  228.                             else
  229.                             {
  230.                                 Error = IoErr();
  231.  
  232.                                 break;
  233.                             }
  234.                         }
  235.  
  236.                         if(Chunk -> cn_ID == ID_WIND)
  237.                         {
  238.                             if(ReadChunkBytes(Handle,&SizeBox,sizeof(struct IBox)) == sizeof(struct IBox))
  239.                             {
  240.                                 FastWindowLeft        = SizeBox . Left;
  241.                                 FastWindowTop        = SizeBox . Top;
  242.                                 FastWindowHeight    = SizeBox . Height;
  243.                             }
  244.                             else
  245.                             {
  246.                                 Error = IoErr();
  247.  
  248.                                 break;
  249.                             }
  250.                         }
  251.  
  252.                         if(Chunk -> cn_ID == ID_FAST)
  253.                         {
  254.                             if(Node = NewFastMacro("",""))
  255.                             {
  256.                                 if(ReadChunkBytes(Handle,Node -> mn_Macro,20) == 20)
  257.                                 {
  258.                                     if(ReadChunkBytes(Handle,Node -> mn_Code,256) == 256)
  259.                                     {
  260.                                         AddTail(&NewFastMacroList,(struct Node *)Node);
  261.  
  262.                                         NewFastMacroCount++;
  263.  
  264.                                         Success = TRUE;
  265.                                     }
  266.                                     else
  267.                                     {
  268.                                         Error = IoErr();
  269.  
  270.                                         break;
  271.                                     }
  272.                                 }
  273.                                 else
  274.                                 {
  275.                                     Error = IoErr();
  276.  
  277.                                     break;
  278.                                 }
  279.                             }
  280.                             else
  281.                             {
  282.                                 Error = ERR_NO_MEM;
  283.  
  284.                                 break;
  285.                             }
  286.                         }
  287.                     }
  288.  
  289.                     if(Success)
  290.                     {
  291.                         if(NewFastMacroList . lh_Head -> ln_Succ)
  292.                         {
  293.                             FreeList(FastMacroList);
  294.  
  295.                             MoveList(&NewFastMacroList,FastMacroList);
  296.  
  297.                             FastMacroCount = NewFastMacroCount;
  298.                         }
  299.                     }
  300.                     else
  301.                         FreeList(&NewFastMacroList);
  302.                 }
  303.  
  304.                 CloseIFF(Handle);
  305.             }
  306.  
  307.             Close(Handle -> iff_Stream);
  308.         }
  309.         else
  310.             Error = IoErr();
  311.  
  312.         FreeIFF(Handle);
  313.     }
  314.     else
  315.         Error = ERR_NO_MEM;
  316.  
  317.     if(Error)
  318.         SetIoErr(Error);
  319.  
  320.     return(Success);
  321. }
  322.